home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / misc / emu / atari800_tr.lzh / cpu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-24  |  50.6 KB  |  2,713 lines
  1. /*
  2.     Ideas for Speed Improvements
  3.     ============================
  4.  
  5.     N = (result >= 128) could become N = NTAB[result];
  6.  
  7.         This saves the branch which breaks the
  8.         pipeline.
  9.  
  10.     Flags could be 0x00 or 0xff instead of 0x00 or 0x01
  11.  
  12.         This allows branches to be implemented as
  13.         follows :-
  14.  
  15.         BEQ    PC += (offset & Z)
  16.         BNE    PC += (offset & (~Z))
  17.  
  18.         again, this prevents the pipeline from
  19.         being broken.
  20.  
  21.     The 6502 emulation ignore memory attributes for
  22.     instruction fetch. This is because the instruction
  23.     must come from either RAM or ROM. A program that
  24.     executes instructions from within hardware
  25.     addresses will fail since there is never any
  26.     usable code there.
  27.  
  28.     The 6502 emulation also ignores memory attributes
  29.     for accesses to page 0 and page 1.
  30. */
  31.  
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <string.h>    
  35.  
  36. static char *rcsid = "$Id: cpu.c,v 1.30 1997/09/30 thor,david Exp $";
  37.  
  38. #define    FALSE    0
  39. #define    TRUE    1
  40.  
  41. #define WSYNC_BONUS 7
  42.  
  43. #include "atari.h"
  44. #include "cpu.h"
  45. #include "mem.h"
  46. #include "monitor.h"
  47. #include "patch.h"
  48.  
  49. /*
  50.     ==========================================================
  51.     Emulated Registers and Flags are kept local to this module
  52.     ==========================================================
  53. */
  54.  
  55. #define UPDATE_GLOBAL_REGS regPC=PC;regS=S;regA=A;regX=X;regY=Y
  56. #define UPDATE_LOCAL_REGS PC=regPC;S=regS;A=regA;X=regX;Y=regY
  57.  
  58. UWORD regPC;
  59. UBYTE regA;
  60. UBYTE regP; /* Processor Status Byte (Partial) */
  61. UBYTE regS;
  62. UBYTE regX;
  63. UBYTE regY;
  64.  
  65. static UBYTE    N;    /* bit7 zero (0) or bit 7 non-zero (1) */
  66. static UBYTE    Z;    /* zero (0) or non-zero (1) */
  67. static UBYTE    V;
  68. static UBYTE    C;    /* zero (0) or one(1) */
  69.  
  70. int wsync_bonus=WSYNC_BONUS;
  71.  
  72.  
  73. /*
  74. #define PROFILE
  75. */
  76.  
  77. int tron;
  78.  
  79.  
  80. /*
  81.  * The following array is used for 6502 instruction profiling
  82.  */
  83.  
  84. int count[256];
  85.  
  86. int IRQ;
  87.  
  88. /*
  89.     ===============================================================
  90.     Z flag: This actually contains the result of an operation which
  91.         would modify the Z flag. The value is tested for
  92.         equality by the BEQ and BNE instruction.
  93.     ===============================================================
  94. */
  95.  
  96. void CPU_GetStatus (void)
  97. {
  98.   if (N)
  99.     SetN;
  100.   else
  101.     ClrN;
  102.  
  103.   if (Z)
  104.     ClrZ;
  105.   else
  106.     SetZ;
  107.  
  108.   if (V)
  109.     SetV;
  110.   else
  111.     ClrV;
  112.  
  113.   if (C)
  114.     SetC;
  115.   else
  116.     ClrC;
  117. }
  118.  
  119. void CPU_PutStatus (void)
  120. {
  121.   if (regP & N_FLAG)
  122.     N = 0x80;
  123.   else
  124.     N = 0x00;
  125.  
  126.   if (regP & Z_FLAG)
  127.     Z = 0;
  128.   else
  129.     Z = 1;
  130.  
  131.   if (regP & V_FLAG)
  132.     V = 1;
  133.   else
  134.     V = 0;
  135.  
  136.   if (regP & C_FLAG)
  137.     C = 1;
  138.   else
  139.     C = 0;
  140. }
  141.  
  142. UBYTE BCDtoDEC[256];
  143. UBYTE DECtoBCD[256];
  144.  
  145. void CPU_Reset (void)
  146. {
  147.     int    i;
  148.  
  149.     for (i=0;i<256;i++)
  150.     {
  151.         BCDtoDEC[i] = ((i >> 4) & 0xf) * 10 + (i & 0xf);
  152.         DECtoBCD[i] = (((i % 100) / 10) << 4) | (i % 10);
  153. #ifdef PROFILE
  154.         count[i] = 0;
  155. #endif
  156.     }
  157.  
  158.     IRQ = 0x00;
  159.  
  160.     regP = 0x20; /* The unused bit is always 1 */
  161.     regS = 0xff;
  162.     regPC = DPeek(0xfffc);
  163. }
  164.  
  165. #define AND(t_data) data = t_data; Z = N = A &= data
  166. #define CMP(t_data) data = t_data; Z = N = A - data; C = (A >= data)
  167. #define CPX(t_data) data = t_data; Z = N = X - data; C = (X >= data);
  168. #define CPY(t_data) data = t_data; Z = N = Y - data; C = (Y >= data);
  169. #define EOR(t_data) data = t_data; Z = N = A ^= data;
  170. #define LDA(data) Z = N = A = data;
  171. #define LDX(data) Z = N = X = data;
  172. #define LDY(data) Z = N = Y = data;
  173. #define ORA(t_data) data = t_data; Z = N = A |= data
  174.  
  175. /* The following flag was introduced by THOR. Faster means uncompatible 6502
  176.    code, no emulation of 6502 bugs. Defaults to slower. */
  177.  
  178. #ifdef FASTER_CPU
  179. #define MASK_FF(a) (a)
  180. #else
  181. #define MASK_FF(a) ((a) & 0xff)
  182. #endif
  183.  
  184. #define PHP data =  (N & 0x80); \
  185.             data |= V ? 0x40 : 0; \
  186.             data |= (regP & 0x3c); \
  187.         data |= (Z == 0) ? 0x02 : 0; \
  188.         data |= C; \
  189.         memory[0x0100 + MASK_FF(S--)] = data;
  190.  
  191. #define PLP data = memory[0x0100 + MASK_FF(++S)]; \
  192.         N = (data & 0x80); \
  193.         V = (data & 0x40) ? 1 : 0; \
  194.         Z = (data & 0x02) ? 0 : 1; \
  195.         C = (data & 0x01); \
  196.             regP = (data & 0x3c) | 0x20;
  197.  
  198. void NMI (void)
  199. {
  200.   UBYTE S = regS;
  201.   UBYTE data;
  202.  
  203.   memory[0x0100 + MASK_FF(S--)] = regPC >> 8;
  204.   memory[0x0100 + MASK_FF(S--)] = regPC & 0xff;
  205.   PHP;
  206.   SetI;
  207.   regPC = DPeek(0xfffa);
  208.   regS = S;
  209. }
  210.  
  211. void CheckIRQ (void)
  212. {
  213. UBYTE S;
  214. UBYTE data;
  215.  
  216.   if (IRQ)
  217.     {
  218.       if (!(regP & I_FLAG))
  219.     {
  220. /*      printf("Got IRQ\n"); */
  221.       S = regS;
  222.       memory[0x0100 + MASK_FF(S--)] = regPC >> 8;
  223.       memory[0x0100 + MASK_FF(S--)] = regPC & 0xff;
  224.       PHP;
  225.       SetI;
  226.       regPC = DPeek(0xfffe);
  227.       regS = S;
  228.       IRQ = 0;
  229.     }
  230.     }
  231.  
  232. }
  233.  
  234. void GenerateIRQ(void)
  235. {
  236.   IRQ = 1;
  237.   CheckIRQ();
  238. }
  239.  
  240. /*
  241.     ==============================================================
  242.     The first switch statement is used to determine the addressing
  243.     mode, while the second switch implements the opcode. When I
  244.     have more confidence that these are working correctly they
  245.     will be combined into a single switch statement. At the
  246.     moment changes can be made very easily.
  247.     ==============================================================
  248. */
  249.  
  250. int cycles[256] =
  251. {
  252.   7, 2, 0, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6,
  253.   2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7,
  254.   6, 6, 0, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6,
  255.   2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7,
  256.  
  257.   6, 6, 0, 8, 3, 3, 7, 5, 3, 2, 2, 2, 3, 4, 6, 6,
  258.   2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 0, 7,
  259.   6, 6, 0, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6,
  260.   2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7,
  261.  
  262.   2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4,
  263.   2, 6, 0, 6, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5,
  264.   2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4,
  265.   2, 5, 0, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4,
  266.  
  267.   2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6,
  268.   2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7,
  269.   2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6,
  270.   2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7
  271. };
  272.  
  273. int GO (int ncycles)
  274. {
  275. #ifdef GNU_C
  276.   static void *opcode[256] =
  277.     {
  278.       &&opcode_00, &&opcode_01, &&opcode_02, &&opcode_03,
  279.       &&opcode_04, &&opcode_05, &&opcode_06, &&opcode_07,
  280.       &&opcode_08, &&opcode_09, &&opcode_0a, &&opcode_0b,
  281.       &&opcode_0c, &&opcode_0d, &&opcode_0e, &&opcode_0f,
  282.  
  283.       &&opcode_10, &&opcode_11, &&opcode_12, &&opcode_13,
  284.       &&opcode_14, &&opcode_15, &&opcode_16, &&opcode_17,
  285.       &&opcode_18, &&opcode_19, &&opcode_1a, &&opcode_1b,
  286.       &&opcode_1c, &&opcode_1d, &&opcode_1e, &&opcode_1f,
  287.  
  288.       &&opcode_20, &&opcode_21, &&opcode_22, &&opcode_23,
  289.       &&opcode_24, &&opcode_25, &&opcode_26, &&opcode_27,
  290.       &&opcode_28, &&opcode_29, &&opcode_2a, &&opcode_2b,
  291.       &&opcode_2c, &&opcode_2d, &&opcode_2e, &&opcode_2f,
  292.  
  293.       &&opcode_30, &&opcode_31, &&opcode_32, &&opcode_33,
  294.       &&opcode_34, &&opcode_35, &&opcode_36, &&opcode_37,
  295.       &&opcode_38, &&opcode_39, &&opcode_3a, &&opcode_3b,
  296.       &&opcode_3c, &&opcode_3d, &&opcode_3e, &&opcode_3f,
  297.  
  298.       &&opcode_40, &&opcode_41, &&opcode_42, &&opcode_43,
  299.       &&opcode_44, &&opcode_45, &&opcode_46, &&opcode_47,
  300.       &&opcode_48, &&opcode_49, &&opcode_4a, &&opcode_4b,
  301.       &&opcode_4c, &&opcode_4d, &&opcode_4e, &&opcode_4f,
  302.  
  303.       &&opcode_50, &&opcode_51, &&opcode_52, &&opcode_53,
  304.       &&opcode_54, &&opcode_55, &&opcode_56, &&opcode_57,
  305.       &&opcode_58, &&opcode_59, &&opcode_5a, &&opcode_5b,
  306.       &&opcode_5c, &&opcode_5d, &&opcode_5e, &&opcode_5f,
  307.  
  308.       &&opcode_60, &&opcode_61, &&opcode_62, &&opcode_63,
  309.       &&opcode_64, &&opcode_65, &&opcode_66, &&opcode_67,
  310.       &&opcode_68, &&opcode_69, &&opcode_6a, &&opcode_6b,
  311.       &&opcode_6c, &&opcode_6d, &&opcode_6e, &&opcode_6f,
  312.  
  313.       &&opcode_70, &&opcode_71, &&opcode_72, &&opcode_73,
  314.       &&opcode_74, &&opcode_75, &&opcode_76, &&opcode_77,
  315.       &&opcode_78, &&opcode_79, &&opcode_7a, &&opcode_7b,
  316.       &&opcode_7c, &&opcode_7d, &&opcode_7e, &&opcode_7f,
  317.  
  318.       &&opcode_80, &&opcode_81, &&opcode_82, &&opcode_83,
  319.       &&opcode_84, &&opcode_85, &&opcode_86, &&opcode_87,
  320.       &&opcode_88, &&opcode_89, &&opcode_8a, &&opcode_8b,
  321.       &&opcode_8c, &&opcode_8d, &&opcode_8e, &&opcode_8f,
  322.  
  323.       &&opcode_90, &&opcode_91, &&opcode_92, &&opcode_93,
  324.       &&opcode_94, &&opcode_95, &&opcode_96, &&opcode_97,
  325.       &&opcode_98, &&opcode_99, &&opcode_9a, &&opcode_9b,
  326.       &&opcode_9c, &&opcode_9d, &&opcode_9e, &&opcode_9f,
  327.  
  328.       &&opcode_a0, &&opcode_a1, &&opcode_a2, &&opcode_a3,
  329.       &&opcode_a4, &&opcode_a5, &&opcode_a6, &&opcode_a7,
  330.       &&opcode_a8, &&opcode_a9, &&opcode_aa, &&opcode_ab,
  331.       &&opcode_ac, &&opcode_ad, &&opcode_ae, &&opcode_af,
  332.  
  333.       &&opcode_b0, &&opcode_b1, &&opcode_b2, &&opcode_b3,
  334.       &&opcode_b4, &&opcode_b5, &&opcode_b6, &&opcode_b7,
  335.       &&opcode_b8, &&opcode_b9, &&opcode_ba, &&opcode_bb,
  336.       &&opcode_bc, &&opcode_bd, &&opcode_be, &&opcode_bf,
  337.  
  338.       &&opcode_c0, &&opcode_c1, &&opcode_c2, &&opcode_c3,
  339.       &&opcode_c4, &&opcode_c5, &&opcode_c6, &&opcode_c7,
  340.       &&opcode_c8, &&opcode_c9, &&opcode_ca, &&opcode_cb,
  341.       &&opcode_cc, &&opcode_cd, &&opcode_ce, &&opcode_cf,
  342.  
  343.       &&opcode_d0, &&opcode_d1, &&opcode_d2, &&opcode_d3,
  344.       &&opcode_d4, &&opcode_d5, &&opcode_d6, &&opcode_d7,
  345.       &&opcode_d8, &&opcode_d9, &&opcode_da, &&opcode_db,
  346.       &&opcode_dc, &&opcode_dd, &&opcode_de, &&opcode_df,
  347.  
  348.       &&opcode_e0, &&opcode_e1, &&opcode_e2, &&opcode_e3,
  349.       &&opcode_e4, &&opcode_e5, &&opcode_e6, &&opcode_e7,
  350.       &&opcode_e8, &&opcode_e9, &&opcode_ea, &&opcode_eb,
  351.       &&opcode_ec, &&opcode_ed, &&opcode_ee, &&opcode_ef,
  352.  
  353.       &&opcode_f0, &&opcode_f1, &&opcode_f2, &&opcode_f3,
  354.       &&opcode_f4, &&opcode_f5, &&opcode_f6, &&opcode_f7,
  355.       &&opcode_f8, &&opcode_f9, &&opcode_fa, &&opcode_fb,
  356.       &&opcode_fc, &&opcode_fd, &&opcode_fe, &&opcode_ff,
  357.     };
  358. #endif
  359.  
  360.   UWORD PC;
  361.   UBYTE S;
  362.   UBYTE A;
  363.   UBYTE X;
  364.   UBYTE Y;
  365.  
  366.   UWORD    addr;
  367.   UBYTE    data;
  368.  
  369. /*
  370.    This used to be in the main loop but has been removed to improve
  371.    execution speed. It does not seem to have any adverse effect on
  372.    the emulation for two reasons:-
  373.  
  374.    1. NMI's will can only be raised in atari_custom.c - there is
  375.       no way an NMI can be generated whilst in this routine.
  376.  
  377.    2. The timing of the IRQs are not that critical.
  378. */
  379.  
  380.   CheckIRQ();
  381.  
  382.   UPDATE_LOCAL_REGS;
  383.  
  384. /*
  385.    =====================================
  386.    Extract Address if Required by Opcode
  387.    =====================================
  388. */
  389.  
  390. #define    ABSOLUTE    addr=(memory[PC+1]<<8)+memory[PC];PC+=2;
  391. #define    ZPAGE        addr=memory[PC++];
  392. #define    ABSOLUTE_X    addr=((memory[PC+1]<<8)+memory[PC])+(UWORD)X;PC+=2;
  393. #define ABSOLUTE_Y    addr=((memory[PC+1]<<8)+memory[PC])+(UWORD)Y;PC+=2;
  394. #define    INDIRECT_X    addr=(UWORD)memory[PC++]+(UWORD)X;addr=(memory[MASK_FF(addr+1)]<<8)+memory[MASK_FF(addr)];
  395. #define    INDIRECT_Y    addr=memory[PC++];addr=(memory[MASK_FF(addr+1)]<<8)+memory[addr]+(UWORD)Y;
  396. #define    ZPAGE_X        addr=MASK_FF(memory[PC++]+X);
  397. #define    ZPAGE_Y        addr=MASK_FF(memory[PC++]+Y);
  398.  
  399. #ifdef FASTER_CPU
  400. #ifdef __i386__
  401. #undef ABSOLUTE
  402. #undef ABSOLUTE_X
  403. #undef ABSOLUTE_Y
  404. #ifdef __ELF__
  405. #define ABSOLUTE asm("movw memory(%1),%0" \
  406.              : "=r" (addr) \
  407.              : "r" ((ULONG)PC)); PC+=2;
  408. #define ABSOLUTE_X asm("movw memory(%1),%0; addw %2,%0" \
  409.                : "=r" (addr) \
  410.                : "r" ((ULONG)PC), "r" ((UWORD)X));PC+=2;
  411. #define ABSOLUTE_Y asm("movw memory(%1),%0; addw %2,%0" \
  412.                : "=r" (addr) \
  413.                : "r" ((ULONG)PC), "r" ((UWORD)Y));PC+=2;
  414. #else
  415. #define ABSOLUTE asm("movw _memory(%1),%0" \
  416.              : "=r" (addr) \
  417.              : "r" ((ULONG)PC)); PC+=2;
  418. #define ABSOLUTE_X asm("movw _memory(%1),%0; addw %2,%0" \
  419.                : "=r" (addr) \
  420.                : "r" ((ULONG)PC), "r" ((UWORD)X));PC+=2;
  421. #define ABSOLUTE_Y asm("movw _memory(%1),%0; addw %2,%0" \
  422.                : "=r" (addr) \
  423.                : "r" ((ULONG)PC), "r" ((UWORD)Y));PC+=2;
  424. #endif
  425. #endif
  426. #endif
  427.  
  428.   for(;;)
  429.     {
  430.     int op;
  431.  
  432. #ifdef TRACE
  433.       if (tron)
  434.     { 
  435.       disassemble (PC, PC+1);
  436.       printf ("\tA=%2x, X=%2x, Y=%2x, S=%2x\n",
  437.           A, X, Y, S);
  438.     }
  439. #endif
  440.  
  441.  
  442.  
  443. #ifdef PROFILE
  444.       count[memory[PC]]++;
  445. #endif
  446.       op=memory[PC];
  447.       
  448.       if (ncycles<cycles[op])
  449.     break;
  450.  
  451.       ncycles -= cycles[op];
  452.  
  453.       /* UPDATE_GLOBAL_REGS; */
  454.  
  455.       PC++;
  456.  
  457. #ifdef GNU_C
  458.       goto *opcode[op];
  459. #else
  460.       switch (op)
  461.     {
  462.     case 0x00 :
  463.       goto opcode_00;
  464.     case 0x01 :
  465.       goto opcode_01;
  466.     case 0x02 :
  467.       goto opcode_02;
  468.     case 0x03 :
  469.       goto opcode_03;
  470.     case 0x04 :
  471.       goto opcode_04;
  472.     case 0x05 :
  473.       goto opcode_05;
  474.     case 0x06 :
  475.       goto opcode_06;
  476.     case 0x07 :
  477.       goto opcode_07;
  478.     case 0x08 :
  479.       goto opcode_08;
  480.     case 0x09 :
  481.       goto opcode_09;
  482.     case 0x0a :
  483.       goto opcode_0a;
  484.     case 0x0b :
  485.       goto opcode_0b;
  486.     case 0x0c :
  487.       goto opcode_0c;
  488.     case 0x0d :
  489.       goto opcode_0d;
  490.     case 0x0e :
  491.       goto opcode_0e;
  492.     case 0x0f :
  493.       goto opcode_0f;
  494.  
  495.     case 0x10 :
  496.       goto opcode_10;
  497.     case 0x11 :
  498.       goto opcode_11;
  499.     case 0x12 :
  500.       goto opcode_12;
  501.     case 0x13 :
  502.       goto opcode_13;
  503.     case 0x14 :
  504.       goto opcode_14;
  505.     case 0x15 :
  506.       goto opcode_15;
  507.     case 0x16 :
  508.       goto opcode_16;
  509.     case 0x17 :
  510.       goto opcode_17;
  511.     case 0x18 :
  512.       goto opcode_18;
  513.     case 0x19 :
  514.       goto opcode_19;
  515.     case 0x1a :
  516.       goto opcode_1a;
  517.     case 0x1b :
  518.       goto opcode_1b;
  519.     case 0x1c :
  520.       goto opcode_1c;
  521.     case 0x1d :
  522.       goto opcode_1d;
  523.     case 0x1e :
  524.       goto opcode_1e;
  525.     case 0x1f :
  526.       goto opcode_1f;
  527.  
  528.     case 0x20 :
  529.       goto opcode_20;
  530.     case 0x21 :
  531.       goto opcode_21;
  532.     case 0x22 :
  533.       goto opcode_22;
  534.     case 0x23 :
  535.       goto opcode_23;
  536.     case 0x24 :
  537.       goto opcode_24;
  538.     case 0x25 :
  539.       goto opcode_25;
  540.     case 0x26 :
  541.       goto opcode_26;
  542.     case 0x27 :
  543.       goto opcode_27;
  544.     case 0x28 :
  545.       goto opcode_28;
  546.     case 0x29 :
  547.       goto opcode_29;
  548.     case 0x2a :
  549.       goto opcode_2a;
  550.     case 0x2b :
  551.       goto opcode_2b;
  552.     case 0x2c :
  553.       goto opcode_2c;
  554.     case 0x2d :
  555.       goto opcode_2d;
  556.     case 0x2e :
  557.       goto opcode_2e;
  558.     case 0x2f :
  559.       goto opcode_2f;
  560.  
  561.     case 0x30 :
  562.       goto opcode_30;
  563.     case 0x31 :
  564.       goto opcode_31;
  565.     case 0x32 :
  566.       goto opcode_32;
  567.     case 0x33 :
  568.       goto opcode_33;
  569.     case 0x34 :
  570.       goto opcode_34;
  571.     case 0x35 :
  572.       goto opcode_35;
  573.     case 0x36 :
  574.       goto opcode_36;
  575.     case 0x37 :
  576.       goto opcode_37;
  577.     case 0x38 :
  578.       goto opcode_38;
  579.     case 0x39 :
  580.       goto opcode_39;
  581.     case 0x3a :
  582.       goto opcode_3a;
  583.     case 0x3b :
  584.       goto opcode_3b;
  585.     case 0x3c :
  586.       goto opcode_3c;
  587.     case 0x3d :
  588.       goto opcode_3d;
  589.     case 0x3e :
  590.       goto opcode_3e;
  591.     case 0x3f :
  592.       goto opcode_3f;
  593.  
  594.     case 0x40 :
  595.       goto opcode_40;
  596.     case 0x41 :
  597.       goto opcode_41;
  598.     case 0x42 :
  599.       goto opcode_42;
  600.     case 0x43 :
  601.       goto opcode_43;
  602.     case 0x44 :
  603.       goto opcode_44;
  604.     case 0x45 :
  605.       goto opcode_45;
  606.     case 0x46 :
  607.       goto opcode_46;
  608.     case 0x47 :
  609.       goto opcode_47;
  610.     case 0x48 :
  611.       goto opcode_48;
  612.     case 0x49 :
  613.       goto opcode_49;
  614.     case 0x4a :
  615.       goto opcode_4a;
  616.     case 0x4b :
  617.       goto opcode_4b;
  618.     case 0x4c :
  619.       goto opcode_4c;
  620.     case 0x4d :
  621.       goto opcode_4d;
  622.     case 0x4e :
  623.       goto opcode_4e;
  624.     case 0x4f :
  625.       goto opcode_4f;
  626.  
  627.     case 0x50 :
  628.       goto opcode_50;
  629.     case 0x51 :
  630.       goto opcode_51;
  631.     case 0x52 :
  632.       goto opcode_52;
  633.     case 0x53 :
  634.       goto opcode_53;
  635.     case 0x54 :
  636.       goto opcode_54;
  637.     case 0x55 :
  638.       goto opcode_55;
  639.     case 0x56 :
  640.       goto opcode_56;
  641.     case 0x57 :
  642.       goto opcode_57;
  643.     case 0x58 :
  644.       goto opcode_58;
  645.     case 0x59 :
  646.       goto opcode_59;
  647.     case 0x5a :
  648.       goto opcode_5a;
  649.     case 0x5b :
  650.       goto opcode_5b;
  651.     case 0x5c :
  652.       goto opcode_5c;
  653.     case 0x5d :
  654.       goto opcode_5d;
  655.     case 0x5e :
  656.       goto opcode_5e;
  657.     case 0x5f :
  658.       goto opcode_5f;
  659.  
  660.     case 0x60 :
  661.       goto opcode_60;
  662.     case 0x61 :
  663.       goto opcode_61;
  664.     case 0x62 :
  665.       goto opcode_62;
  666.     case 0x63 :
  667.       goto opcode_63;
  668.     case 0x64 :
  669.       goto opcode_64;
  670.     case 0x65 :
  671.       goto opcode_65;
  672.     case 0x66 :
  673.       goto opcode_66;
  674.     case 0x67 :
  675.       goto opcode_67;
  676.     case 0x68 :
  677.       goto opcode_68;
  678.     case 0x69 :
  679.       goto opcode_69;
  680.     case 0x6a :
  681.       goto opcode_6a;
  682.     case 0x6b :
  683.       goto opcode_6b;
  684.     case 0x6c :
  685.       goto opcode_6c;
  686.     case 0x6d :
  687.       goto opcode_6d;
  688.     case 0x6e :
  689.       goto opcode_6e;
  690.     case 0x6f :
  691.       goto opcode_6f;
  692.  
  693.     case 0x70 :
  694.       goto opcode_70;
  695.     case 0x71 :
  696.       goto opcode_71;
  697.     case 0x72 :
  698.       goto opcode_72;
  699.     case 0x73 :
  700.       goto opcode_73;
  701.     case 0x74 :
  702.       goto opcode_74;
  703.     case 0x75 :
  704.       goto opcode_75;
  705.     case 0x76 :
  706.       goto opcode_76;
  707.     case 0x77 :
  708.       goto opcode_77;
  709.     case 0x78 :
  710.       goto opcode_78;
  711.     case 0x79 :
  712.       goto opcode_79;
  713.     case 0x7a :
  714.       goto opcode_7a;
  715.     case 0x7b :
  716.       goto opcode_7b;
  717.     case 0x7c :
  718.       goto opcode_7c;
  719.     case 0x7d :
  720.       goto opcode_7d;
  721.     case 0x7e :
  722.       goto opcode_7e;
  723.     case 0x7f :
  724.       goto opcode_7f;
  725.  
  726.     case 0x80 :
  727.       goto opcode_80;
  728.     case 0x81 :
  729.       goto opcode_81;
  730.     case 0x82 :
  731.       goto opcode_82;
  732.     case 0x83 :
  733.       goto opcode_83;
  734.     case 0x84 :
  735.       goto opcode_84;
  736.     case 0x85 :
  737.       goto opcode_85;
  738.     case 0x86 :
  739.       goto opcode_86;
  740.     case 0x87 :
  741.       goto opcode_87;
  742.     case 0x88 :
  743.       goto opcode_88;
  744.     case 0x89 :
  745.       goto opcode_89;
  746.     case 0x8a :
  747.       goto opcode_8a;
  748.     case 0x8b :
  749.       goto opcode_8b;
  750.     case 0x8c :
  751.       goto opcode_8c;
  752.     case 0x8d :
  753.       goto opcode_8d;
  754.     case 0x8e :
  755.       goto opcode_8e;
  756.     case 0x8f :
  757.       goto opcode_8f;
  758.  
  759.     case 0x90 :
  760.       goto opcode_90;
  761.     case 0x91 :
  762.       goto opcode_91;
  763.     case 0x92 :
  764.       goto opcode_92;
  765.     case 0x93 :
  766.       goto opcode_93;
  767.     case 0x94 :
  768.       goto opcode_94;
  769.     case 0x95 :
  770.       goto opcode_95;
  771.     case 0x96 :
  772.       goto opcode_96;
  773.     case 0x97 :
  774.       goto opcode_97;
  775.     case 0x98 :
  776.       goto opcode_98;
  777.     case 0x99 :
  778.       goto opcode_99;
  779.     case 0x9a :
  780.       goto opcode_9a;
  781.     case 0x9b :
  782.       goto opcode_9b;
  783.     case 0x9c :
  784.       goto opcode_9c;
  785.     case 0x9d :
  786.       goto opcode_9d;
  787.     case 0x9e :
  788.       goto opcode_9e;
  789.     case 0x9f :
  790.       goto opcode_9f;
  791.  
  792.     case 0xa0 :
  793.       goto opcode_a0;
  794.     case 0xa1 :
  795.       goto opcode_a1;
  796.     case 0xa2 :
  797.       goto opcode_a2;
  798.     case 0xa3 :
  799.       goto opcode_a3;
  800.     case 0xa4 :
  801.       goto opcode_a4;
  802.     case 0xa5 :
  803.       goto opcode_a5;
  804.     case 0xa6 :
  805.       goto opcode_a6;
  806.     case 0xa7 :
  807.       goto opcode_a7;
  808.     case 0xa8 :
  809.       goto opcode_a8;
  810.     case 0xa9 :
  811.       goto opcode_a9;
  812.     case 0xaa :
  813.       goto opcode_aa;
  814.     case 0xab :
  815.       goto opcode_ab;
  816.     case 0xac :
  817.       goto opcode_ac;
  818.     case 0xad :
  819.       goto opcode_ad;
  820.     case 0xae :
  821.       goto opcode_ae;
  822.     case 0xaf :
  823.       goto opcode_af;
  824.  
  825.     case 0xb0 :
  826.       goto opcode_b0;
  827.     case 0xb1 :
  828.       goto opcode_b1;
  829.     case 0xb2 :
  830.       goto opcode_b2;
  831.     case 0xb3 :
  832.       goto opcode_b3;
  833.     case 0xb4 :
  834.       goto opcode_b4;
  835.     case 0xb5 :
  836.       goto opcode_b5;
  837.     case 0xb6 :
  838.       goto opcode_b6;
  839.     case 0xb7 :
  840.       goto opcode_b7;
  841.     case 0xb8 :
  842.       goto opcode_b8;
  843.     case 0xb9 :
  844.       goto opcode_b9;
  845.     case 0xba :
  846.       goto opcode_ba;
  847.     case 0xbb :
  848.       goto opcode_bb;
  849.     case 0xbc :
  850.       goto opcode_bc;
  851.     case 0xbd :
  852.       goto opcode_bd;
  853.     case 0xbe :
  854.       goto opcode_be;
  855.     case 0xbf :
  856.       goto opcode_bf;
  857.  
  858.     case 0xc0 :
  859.       goto opcode_c0;
  860.     case 0xc1 :
  861.       goto opcode_c1;
  862.     case 0xc2 :
  863.       goto opcode_c2;
  864.     case 0xc3 :
  865.       goto opcode_c3;
  866.     case 0xc4 :
  867.       goto opcode_c4;
  868.     case 0xc5 :
  869.       goto opcode_c5;
  870.     case 0xc6 :
  871.       goto opcode_c6;
  872.     case 0xc7 :
  873.       goto opcode_c7;
  874.     case 0xc8 :
  875.       goto opcode_c8;
  876.     case 0xc9 :
  877.       goto opcode_c9;
  878.     case 0xca :
  879.       goto opcode_ca;
  880.     case 0xcb :
  881.       goto opcode_cb;
  882.     case 0xcc :
  883.       goto opcode_cc;
  884.     case 0xcd :
  885.       goto opcode_cd;
  886.     case 0xce :
  887.       goto opcode_ce;
  888.     case 0xcf :
  889.       goto opcode_cf;
  890.  
  891.     case 0xd0 :
  892.       goto opcode_d0;
  893.     case 0xd1 :
  894.       goto opcode_d1;
  895.     case 0xd2 :
  896.       goto opcode_d2;
  897.     case 0xd3 :
  898.       goto opcode_d3;
  899.     case 0xd4 :
  900.       goto opcode_d4;
  901.     case 0xd5 :
  902.       goto opcode_d5;
  903.     case 0xd6 :
  904.       goto opcode_d6;
  905.     case 0xd7 :
  906.       goto opcode_d7;
  907.     case 0xd8 :
  908.       goto opcode_d8;
  909.     case 0xd9 :
  910.       goto opcode_d9;
  911.     case 0xda :
  912.       goto opcode_da;
  913.     case 0xdb :
  914.       goto opcode_db;
  915.     case 0xdc :
  916.       goto opcode_dc;
  917.     case 0xdd :
  918.       goto opcode_dd;
  919.     case 0xde :
  920.       goto opcode_de;
  921.     case 0xdf :
  922.       goto opcode_df;
  923.  
  924.     case 0xe0 :
  925.       goto opcode_e0;
  926.     case 0xe1 :
  927.       goto opcode_e1;
  928.     case 0xe2 :
  929.       goto opcode_e2;
  930.     case 0xe3 :
  931.       goto opcode_e3;
  932.     case 0xe4 :
  933.       goto opcode_e4;
  934.     case 0xe5 :
  935.       goto opcode_e5;
  936.     case 0xe6 :
  937.       goto opcode_e6;
  938.     case 0xe7 :
  939.       goto opcode_e7;
  940.     case 0xe8 :
  941.       goto opcode_e8;
  942.     case 0xe9 :
  943.       goto opcode_e9;
  944.     case 0xea :
  945.       goto opcode_ea;
  946.     case 0xeb :
  947.       goto opcode_eb;
  948.     case 0xec :
  949.       goto opcode_ec;
  950.     case 0xed :
  951.       goto opcode_ed;
  952.     case 0xee :
  953.       goto opcode_ee;
  954.     case 0xef :
  955.       goto opcode_ef;
  956.  
  957.     case 0xf0 :
  958.       goto opcode_f0;
  959.     case 0xf1 :
  960.       goto opcode_f1;
  961.     case 0xf2 :
  962.       goto opcode_f2;
  963.     case 0xf3 :
  964.       goto opcode_f3;
  965.     case 0xf4 :
  966.       goto opcode_f4;
  967.     case 0xf5 :
  968.       goto opcode_f5;
  969.     case 0xf6 :
  970.       goto opcode_f6;
  971.     case 0xf7 :
  972.       goto opcode_f7;
  973.     case 0xf8 :
  974.       goto opcode_f8;
  975.     case 0xf9 :
  976.       goto opcode_f9;
  977.     case 0xfa :
  978.       goto opcode_fa;
  979.     case 0xfb :
  980.       goto opcode_fb;
  981.     case 0xfc :
  982.       goto opcode_fc;
  983.     case 0xfd :
  984.       goto opcode_fd;
  985.     case 0xfe :
  986.       goto opcode_fe;
  987.     case 0xff :
  988.       goto opcode_ff;
  989.     }
  990. #endif
  991.  
  992.     opcode_00: /* BRK */
  993.       if (!(regP & I_FLAG))
  994.     {
  995.       UWORD retadr = PC + 1;
  996.       memory[0x0100 + MASK_FF(S--)] = retadr >> 8;
  997.       memory[0x0100 + MASK_FF(S--)] = retadr & 0xff;
  998.       SetB;
  999.       PHP;
  1000.       SetI;
  1001.       PC = DPeek(0xfffe);
  1002.     }
  1003.       goto next;
  1004.  
  1005.     opcode_01: /* ORA (ab,x) */
  1006.       INDIRECT_X;
  1007.       ORA (GetByte(addr));
  1008.       goto next;
  1009.  
  1010.     opcode_03: /* #SLO (ab,x) */
  1011.       INDIRECT_X;
  1012.       data = GetByte(addr);
  1013.       C = (data & 0x80) ? 1 : 0;
  1014.       Z = N = A |= data << 1;
  1015.       goto next;
  1016.  
  1017.     opcode_04: /* NOP (2 bytes) [unofficial] */
  1018.       PC++;
  1019.       goto next;
  1020.  
  1021.     opcode_05: /* ORA ab */
  1022.       ZPAGE;
  1023.       ORA (memory[addr]);
  1024.       goto next;
  1025.  
  1026.     opcode_06: /* ASL ab */
  1027.       ZPAGE;
  1028.       data = memory[addr];
  1029.       C = (data & 0x80) ? 1 : 0;
  1030.       Z = N = data << 1;
  1031.       memory[addr] = Z;
  1032.       goto next;
  1033.     
  1034.     opcode_07: /* #SLO ab */
  1035.       ZPAGE;
  1036.       data = memory[addr];
  1037.       C = (data & 0x80) ? 1 : 0;
  1038.       data <<= 1;
  1039.       memory[addr] = data;
  1040.       Z = N = A |= data;
  1041.       goto next;
  1042.  
  1043.     opcode_08: /* PHP */
  1044.       PHP;
  1045.       goto next;
  1046.  
  1047.     opcode_09: /* ORA #ab */
  1048.       ORA (memory[PC++]);
  1049.       goto next;
  1050.  
  1051.     opcode_0b: /* #ANC */
  1052.       AND (memory[PC++]);
  1053.       C = N;
  1054.       goto next;
  1055.  
  1056.     opcode_0a: /* ASL */
  1057.       C = (A & 0x80) ? 1 : 0;
  1058.       Z = N = A = A << 1;
  1059.       goto next;
  1060.  
  1061.     opcode_0c: /* NOP (3 bytes) [unofficial] */
  1062.       ABSOLUTE;
  1063.       data = GetByte(addr);
  1064.       goto next;
  1065.  
  1066.     opcode_0d: /* ORA abcd */
  1067.       ABSOLUTE;
  1068.       ORA (GetByte(addr));
  1069.       goto next;
  1070.  
  1071.     opcode_0e: /* ASL abcd */
  1072.       ABSOLUTE;
  1073.       data = GetByte(addr);
  1074.       C = (data & 0x80) ? 1 : 0;
  1075.       Z = N = data << 1;
  1076.       PutByte(addr, Z);
  1077.       goto next;
  1078.  
  1079.     opcode_0f: /* #SLO abcd */
  1080.       ABSOLUTE;
  1081.       data = GetByte(addr);
  1082.       C = (data & 0x80) ? 1 : 0;
  1083.       data <<= 1;
  1084.       PutByte(addr,data);
  1085.       Z = N = A |= data;
  1086.       goto next;
  1087.  
  1088.     opcode_10: /* BPL */
  1089.       if (!(N & 0x80))
  1090.     {
  1091.       SBYTE sdata = memory[PC];
  1092.       PC += (SWORD)sdata;
  1093.     }
  1094.       PC++;
  1095.       goto next;
  1096.  
  1097.     opcode_11: /* ORA (ab),y */
  1098.       INDIRECT_Y;
  1099.       ORA (GetByte(addr));
  1100.       goto next;
  1101.  
  1102.     opcode_13: /* #SLO (ab),y */
  1103.       INDIRECT_Y;
  1104.       data=GetByte(addr);
  1105.       C = (data & 0x80) ? 1 : 0;
  1106.       data <<= 1;
  1107.       PutByte(addr,data);
  1108.       Z = N = A |= data;
  1109.       goto next;
  1110.       
  1111.     opcode_14: /* NOP (2 bytes) [unofficial] */
  1112.       PC++;
  1113.       goto next;
  1114.  
  1115.     opcode_15: /* ORA ab,x */
  1116.       ZPAGE_X;
  1117.       ORA (memory[addr]);
  1118.       goto next;
  1119.  
  1120.     opcode_16: /* ASL ab,x */
  1121.       ZPAGE_X;
  1122.       data = memory[addr];
  1123.       C = (data & 0x80) ? 1 : 0;
  1124.       Z = N = data << 1;
  1125.       memory[addr] = Z;
  1126.       goto next;
  1127.  
  1128.     opcode_17: /* #SLO ab,x */
  1129.       ZPAGE_X;
  1130.       data = memory[addr];
  1131.       C = (data & 0x80) ? 1 : 0;
  1132.       memory[addr] = data;
  1133.       Z = N = A |= data << 1;
  1134.       goto next;
  1135.  
  1136.     opcode_18: /* CLC */
  1137.       C = 0;
  1138.       goto next;
  1139.  
  1140.     opcode_19: /* ORA abcd,y */
  1141.       ABSOLUTE_Y;
  1142.       ORA (GetByte(addr));
  1143.       goto next;
  1144.  
  1145.     opcode_1a: /* NOP (1 byte) [unofficial] */
  1146.       goto next;
  1147.  
  1148.     opcode_1b: /* #SLO abcd,y */
  1149.       ABSOLUTE_Y;
  1150.       data = GetByte(addr);
  1151.       C = (data & 0x80) ? 1 : 0;
  1152.       data <<= 1;
  1153.       PutByte(addr,data);
  1154.       Z = N = A |= data;
  1155.       goto next;
  1156.  
  1157.     opcode_1c: /* NOP (2 bytes) [unofficial] */
  1158.       ABSOLUTE_X;
  1159.       data = GetByte(addr);
  1160.       goto next;
  1161.  
  1162.     opcode_1d: /* ORA abcd,x */
  1163.       ABSOLUTE_X;
  1164.       ORA (GetByte(addr));
  1165.       goto next;
  1166.  
  1167.     opcode_1e: /* ASL abcd,x */
  1168.       ABSOLUTE_X;
  1169.       data = GetByte(addr);
  1170.       C = (data & 0x80) ? 1 : 0;
  1171.       Z = N = data << 1;
  1172.       PutByte(addr, Z);
  1173.       goto next;
  1174.  
  1175.     opcode_1f: /* #SLO abcd,x */
  1176.       ABSOLUTE_X;
  1177.       data = GetByte(addr);
  1178.       C = (data & 0x80) ? 1 : 0;
  1179.       data <<= 1;
  1180.       PutByte(addr, data);
  1181.       Z = N = A |= data;
  1182.       goto next;
  1183.  
  1184.     opcode_20: /* JSR abcd */
  1185.       {
  1186.     UWORD retadr = PC + 1;
  1187.     memory[0x0100 + MASK_FF(S--)] = retadr >> 8;
  1188.     memory[0x0100 + MASK_FF(S--)] = retadr & 0xff;
  1189.     PC = (memory[PC+1] << 8) | memory[PC];
  1190.       }
  1191.       goto next;
  1192.  
  1193.     opcode_21: /* AND (ab,x) */
  1194.       INDIRECT_X;
  1195.       AND (GetByte(addr));
  1196.       goto next;
  1197.  
  1198.     opcode_23: /* #RLA (ab,x) */
  1199.       INDIRECT_X;
  1200.       data = GetByte(addr);
  1201.       if (C)
  1202.     {
  1203.       C = (data & 0x80) ? 1 : 0;
  1204.       data = (data << 1) | 1;
  1205.     }
  1206.       else
  1207.     {
  1208.       C = (data & 0x80) ? 1 : 0;
  1209.       data = (data << 1);
  1210.     }
  1211.       PutByte(addr,data);
  1212.       Z = N = A &= data;
  1213.       goto next;
  1214.  
  1215.     opcode_24: /* BIT ab */
  1216.       ZPAGE;
  1217.       N = memory[addr];
  1218.       V = N & 0x40;
  1219.       Z = (A & N);
  1220.       goto next;
  1221.  
  1222.     opcode_25: /* AND ab */
  1223.       ZPAGE;
  1224.       AND (memory[addr]);
  1225.       goto next;
  1226.  
  1227.     opcode_26: /* ROL ab */
  1228.       ZPAGE;
  1229.       data = memory[addr];
  1230.       if (C)
  1231.     {
  1232.       C = (data & 0x80) ? 1 : 0;
  1233.       Z = N = (data << 1) | 1;
  1234.     }
  1235.       else
  1236.     {
  1237.       C = (data & 0x80) ? 1 : 0;
  1238.       Z = N = (data << 1);
  1239.     }
  1240.       memory[addr] = Z;
  1241.       goto next;
  1242.  
  1243.     opcode_27: /* #RLA ab */
  1244.       ZPAGE;
  1245.       data = memory[addr];
  1246.       if (C)
  1247.     {
  1248.       C = (data & 0x80) ? 1 : 0;
  1249.       data = (data << 1) | 1;
  1250.     }
  1251.       else
  1252.     {
  1253.       C = (data & 0x80) ? 1 : 0;
  1254.       data = (data << 1);
  1255.     }
  1256.       memory[addr] = data;
  1257.       Z = N = A &= data;
  1258.       goto next;
  1259.  
  1260.     opcode_28: /* PLP */
  1261.       PLP;
  1262.       if (IRQ) {
  1263.     UPDATE_GLOBAL_REGS;
  1264.     CheckIRQ();
  1265.     UPDATE_LOCAL_REGS;
  1266.       }
  1267.       goto next;
  1268.  
  1269.     opcode_29: /* AND #ab */
  1270.       AND (memory[PC++]);
  1271.       goto next;
  1272.  
  1273.     opcode_2a: /* ROL */
  1274.       if (C)
  1275.     {
  1276.       C = (A & 0x80) ? 1 : 0;
  1277.       Z = N = A = (A << 1) | 1;
  1278.     }
  1279.       else
  1280.     {
  1281.       C = (A & 0x80) ? 1 : 0;
  1282.       Z = N = A = (A << 1);
  1283.     }
  1284.       goto next;
  1285.  
  1286.     opcode_2b: /* #ANC */
  1287.       AND (memory[PC++]);
  1288.       C = N;
  1289.       goto next;
  1290.  
  1291.     opcode_2c: /* BIT abcd */
  1292.       ABSOLUTE;
  1293.       N = GetByte(addr);
  1294.       V = N & 0x40;
  1295.       Z = (A & N);
  1296.       goto next;
  1297.  
  1298.     opcode_2d: /* AND abcd */
  1299.       ABSOLUTE;
  1300.       AND (GetByte(addr));
  1301.       goto next;
  1302.  
  1303.     opcode_2e: /* ROL abcd */
  1304.       ABSOLUTE;
  1305.       data = GetByte(addr);
  1306.       if (C)
  1307.     {
  1308.       C = (data & 0x80) ? 1 : 0;
  1309.       Z = N = (data << 1) | 1;
  1310.     }
  1311.       else
  1312.     {
  1313.       C = (data & 0x80) ? 1 : 0;
  1314.       Z = N = (data << 1);
  1315.     }
  1316.       PutByte(addr, Z);
  1317.       goto next;
  1318.  
  1319.     opcode_2f: /* #RLA abcd */
  1320.       ABSOLUTE;
  1321.       data = GetByte(addr);
  1322.       if (C)
  1323.     {
  1324.       C = (data & 0x80) ? 1 : 0;
  1325.       data = (data << 1) | 1;
  1326.     }
  1327.       else
  1328.     {
  1329.       C = (data & 0x80) ? 1 : 0;
  1330.       data = (data << 1);
  1331.     }
  1332.       PutByte(addr,data);
  1333.       Z = N = A &= data;
  1334.       goto next;
  1335.  
  1336.     opcode_30: /* BMI */
  1337.       if (N & 0x80)
  1338.     {
  1339.       SBYTE sdata = memory[PC];
  1340.       PC += (SWORD)sdata;
  1341.     }
  1342.       PC++;
  1343.       goto next;
  1344.  
  1345.     opcode_31: /* AND (ab),y */
  1346.       INDIRECT_Y;
  1347.       AND (GetByte(addr));
  1348.       goto next;
  1349.  
  1350.     opcode_33: /* #RLA (ab),y */
  1351.       INDIRECT_Y;
  1352.       data = GetByte(addr);
  1353.       if (C)
  1354.     {
  1355.       C = (data & 0x80) ? 1 : 0;
  1356.       data = (data << 1) | 1;
  1357.     }
  1358.       else
  1359.     {
  1360.       C = (data & 0x80) ? 1 : 0;
  1361.       data = (data << 1);
  1362.     }
  1363.       PutByte(addr,data);
  1364.       Z = N = A &= data;
  1365.       goto next;
  1366.  
  1367.     opcode_34: /* NOP (2 bytes) [unofficial] */
  1368.       PC++;
  1369.       goto next;
  1370.  
  1371.     opcode_35: /* AND ab,x */
  1372.       ZPAGE_X;
  1373.       AND (memory[addr]);
  1374.       goto next;
  1375.  
  1376.     opcode_36: /* ROL ab,x */
  1377.       ZPAGE_X;
  1378.       data = memory[addr];
  1379.       if (C)
  1380.     {
  1381.       C = (data & 0x80) ? 1 : 0;
  1382.       Z = N = (data << 1) | 1;
  1383.     }
  1384.       else
  1385.     {
  1386.       C = (data & 0x80) ? 1 : 0;
  1387.       Z = N = (data << 1);
  1388.     }
  1389.       memory[addr] = Z;
  1390.       goto next;
  1391.  
  1392.     opcode_37: /* #RLA ab,x */
  1393.       ZPAGE_X;
  1394.       data = memory[addr];
  1395.       if (C)
  1396.     {
  1397.       C = (data & 0x80) ? 1 : 0;
  1398.       data = (data << 1) | 1;
  1399.     }
  1400.       else
  1401.     {
  1402.       C = (data & 0x80) ? 1 : 0;
  1403.       data = (data << 1);
  1404.     }
  1405.       memory[addr] = data;
  1406.       Z = N = A &= data;
  1407.       goto next;
  1408.  
  1409.     opcode_38: /* SEC */
  1410.       C = 1;
  1411.       goto next;
  1412.  
  1413.     opcode_39: /* AND abcd,y */
  1414.       ABSOLUTE_Y;
  1415.       AND (GetByte(addr));
  1416.       goto next;
  1417.  
  1418.     opcode_3a: /* NOP (1 byte) [unofficial] */
  1419.       goto next;
  1420.  
  1421.     opcode_3b: /* #RLA abcd,Y */
  1422.       ABSOLUTE_Y;
  1423.       data = GetByte(addr);
  1424.       if (C)
  1425.     {
  1426.       C = (data & 0x80) ? 1 : 0;
  1427.       data = (data << 1) | 1;
  1428.     }
  1429.       else
  1430.     {
  1431.       C = (data & 0x80) ? 1 : 0;
  1432.       data = (data << 1);
  1433.     }
  1434.       PutByte(addr,data);
  1435.       Z = N = A &= data;
  1436.       goto next;
  1437.  
  1438.     opcode_3c: /* NOP (3 bytes) [unofficial] */
  1439.       ABSOLUTE_X;
  1440.       data = GetByte(addr);
  1441.       goto next;
  1442.  
  1443.     opcode_3d: /* AND abcd,x */
  1444.       ABSOLUTE_X;
  1445.       AND (GetByte(addr));
  1446.       goto next;
  1447.  
  1448.     opcode_3e: /* ROL abcd,x */
  1449.       ABSOLUTE_X;
  1450.       data = GetByte(addr);
  1451.       if (C)
  1452.     {
  1453.       C = (data & 0x80) ? 1 : 0;
  1454.       Z = N = (data << 1) | 1;
  1455.     }
  1456.       else
  1457.     {
  1458.       C = (data & 0x80) ? 1 : 0;
  1459.       Z = N = (data << 1);
  1460.     }
  1461.       PutByte(addr, Z);
  1462.       goto next;
  1463.       
  1464.     opcode_3f: /* #RLA abcd,X */
  1465.       ABSOLUTE_X;
  1466.       data = GetByte(addr);
  1467.       if (C)
  1468.     {
  1469.       C = (data & 0x80) ? 1 : 0;
  1470.       data = (data << 1) | 1;
  1471.     }
  1472.       else
  1473.     {
  1474.       C = (data & 0x80) ? 1 : 0;
  1475.       data = (data << 1);
  1476.     }
  1477.       PutByte(addr,data);
  1478.       Z = N = A &= data;
  1479.       goto next;
  1480.  
  1481.     opcode_40: /* RTI */
  1482.       PLP;
  1483.       data = memory[0x0100 + MASK_FF(++S)];
  1484.       PC = (memory[0x0100 + MASK_FF(++S)] << 8) | data;
  1485.       if (IRQ) {
  1486.     UPDATE_GLOBAL_REGS;
  1487.     CheckIRQ();
  1488.     UPDATE_LOCAL_REGS;
  1489.       }
  1490.       goto next;
  1491.  
  1492.     opcode_41: /* EOR (ab,x) */
  1493.       INDIRECT_X;
  1494.       EOR (GetByte(addr));
  1495.       goto next;
  1496.  
  1497.     opcode_43: /* #LSE (ab,x) */
  1498.       INDIRECT_X;
  1499.       data = GetByte(addr);
  1500.       C = data & 1;
  1501.       data = data >> 1;
  1502.       PutByte(addr,data);
  1503.       N = Z = A ^= data;
  1504.       goto next;
  1505.  
  1506.     opcode_44: /* NOP (2 bytes) [unofficial] */
  1507.       PC++;
  1508.       goto next;
  1509.  
  1510.     opcode_45: /* EOR ab */
  1511.       ZPAGE;
  1512.       EOR (memory[addr]);
  1513.       goto next;
  1514.  
  1515.     opcode_46: /* LSR ab */
  1516.       ZPAGE;
  1517.       data = memory[addr];
  1518.       C = data & 1;
  1519.       Z = data >> 1;
  1520.       N = 0;
  1521.       memory[addr] = Z;
  1522.       goto next;
  1523.  
  1524.     opcode_47: /* #LSE ab */
  1525.       ZPAGE;
  1526.       data = memory[addr];
  1527.       C = data & 1;
  1528.       data = data >> 1;
  1529.       memory[addr] = data;
  1530.       N = Z = A ^= data;
  1531.       goto next;
  1532.  
  1533.     opcode_48: /* PHA */
  1534.       memory[0x0100 + MASK_FF(S--)] = A;
  1535.       goto next;
  1536.  
  1537.     opcode_49: /* EOR #ab */
  1538.       EOR (memory[PC++]);
  1539.       goto next;
  1540.  
  1541.     opcode_4a: /* LSR */
  1542.       C = A & 1;
  1543.       A = A >> 1;
  1544.       N = 0;
  1545.       Z = A;
  1546.       goto next;
  1547.  
  1548.     opcode_4b: /* #ALR #ab */
  1549.       data = A & memory[PC++];
  1550.       C = data & 1;
  1551.       Z = A = data >> 1;
  1552.       N = 0;
  1553.       goto next;
  1554.  
  1555.     opcode_4c: /* JMP abcd */
  1556.       PC = (memory[PC+1] << 8) | memory[PC];
  1557.       goto next;
  1558.  
  1559.     opcode_4d: /* EOR abcd */
  1560.       ABSOLUTE;
  1561.       EOR (GetByte(addr));
  1562.       goto next;
  1563.  
  1564.     opcode_4e: /* LSR abcd */
  1565.       ABSOLUTE;
  1566.       data = GetByte(addr);
  1567.       C = data & 1;
  1568.       Z = data >> 1;
  1569.       N = 0;
  1570.       PutByte(addr, Z);
  1571.       goto next;
  1572.  
  1573.     opcode_4f: /* #LSE abcd */
  1574.       ABSOLUTE;
  1575.       data = GetByte(addr);
  1576.       C = data & 1;
  1577.       data = data >> 1;
  1578.       PutByte(addr,data);
  1579.       N = Z = A ^= data;
  1580.       goto next;
  1581.  
  1582.     opcode_50: /* BVC */
  1583.       if (!V)
  1584.     {
  1585.       SBYTE sdata = memory[PC];
  1586.       PC += (SWORD)sdata;
  1587.     }
  1588.       PC++;
  1589.       goto next;
  1590.  
  1591.     opcode_51: /* EOR (ab),y */
  1592.       INDIRECT_Y;
  1593.       EOR (GetByte(addr));
  1594.       goto next;
  1595.  
  1596.     opcode_53: /* #LSE (ab),y */
  1597.       INDIRECT_Y;
  1598.       data = GetByte(addr);
  1599.       C = data & 1;
  1600.       data = data >> 1;
  1601.       PutByte(addr,data);
  1602.       N = Z = A ^= data;
  1603.       goto next;
  1604.  
  1605.     opcode_54: /* NOP (2 bytes) [unofficial] */
  1606.       PC++;
  1607.       goto next;
  1608.  
  1609.     opcode_55: /* EOR ab,x */
  1610.       ZPAGE_X;
  1611.       EOR (memory[addr]);
  1612.       goto next;
  1613.  
  1614.     opcode_56: /* LSR ab,x */
  1615.       ZPAGE_X;
  1616.       data = memory[addr];
  1617.       C = data & 1;
  1618.       Z = data >> 1;
  1619.       N = 0;
  1620.       memory[addr] = Z;
  1621.       goto next;
  1622.  
  1623.     opcode_57: /* LSE #ab,x */
  1624.       ZPAGE_X;
  1625.       data = memory[addr];
  1626.       C = data & 1;
  1627.       data = data >> 1;
  1628.       memory[addr] = data;
  1629.       N = Z = A ^= data;
  1630.       goto next;
  1631.  
  1632.     opcode_58: /* CLI */
  1633.       ClrI;
  1634.       if (IRQ) {
  1635.     UPDATE_GLOBAL_REGS;
  1636.     CheckIRQ();
  1637.     UPDATE_LOCAL_REGS;
  1638.       }
  1639.       goto next;
  1640.  
  1641.     opcode_59: /* EOR abcd,y */
  1642.       ABSOLUTE_Y;
  1643.       EOR (GetByte(addr));
  1644.       goto next;
  1645.  
  1646.     opcode_5a: /* NOP (1 byte) [unofficial] */
  1647.       goto next;
  1648.  
  1649.     opcode_5b: /* #LSE abcd,Y */
  1650.       ABSOLUTE_Y;
  1651.       data = GetByte(addr);
  1652.       C = data & 1;
  1653.       data = data >> 1;
  1654.       PutByte(addr,data);
  1655.       N = Z = A ^= data;
  1656.       goto next;
  1657.  
  1658.     opcode_5c: /* NOP (3 bytes) [unofficial] */
  1659.       ABSOLUTE_X;
  1660.       data = GetByte(addr);
  1661.       goto next;
  1662.  
  1663.     opcode_5d: /* EOR abcd,x */
  1664.       ABSOLUTE_X;
  1665.       EOR (GetByte(addr));
  1666.       goto next;
  1667.  
  1668.     opcode_5e: /* LSR abcd,x */
  1669.       ABSOLUTE_X;
  1670.       data = GetByte(addr);
  1671.       C = data & 1;
  1672.       Z = data >> 1;
  1673.       N = 0;
  1674.       PutByte(addr, Z);
  1675.       goto next;
  1676.  
  1677.     opcode_5f: /* #LSE abcd,x */
  1678.       ABSOLUTE_X;
  1679.       data = GetByte(addr);
  1680.       C = data & 1;
  1681.       data = data >> 1;
  1682.       PutByte(addr,data);
  1683.       N = Z = A ^= data;
  1684.       goto next;
  1685.  
  1686.     opcode_60: /* RTS */
  1687.       data = memory[0x0100 + MASK_FF(++S)];
  1688.       PC = ((memory[0x0100 + MASK_FF(++S)] << 8) | data) + 1;
  1689.       goto next;
  1690.  
  1691.     opcode_61: /* ADC (ab,x) */
  1692.       INDIRECT_X;
  1693.       data = GetByte(addr);
  1694.       goto adc;
  1695.  
  1696.     opcode_63: /* #RRA (ab,x) */
  1697.       INDIRECT_X;
  1698.       data = GetByte(addr);
  1699.       if (C)
  1700.     {
  1701.       C = data & 1;
  1702.       data = (data >> 1) | 0x80;
  1703.     }
  1704.       else
  1705.     {
  1706.       C = data & 1;
  1707.       data = (data >> 1);
  1708.     }
  1709.       PutByte(addr,data);
  1710.       goto adc;
  1711.  
  1712.     opcode_64: /* NOP (2 bytes) [unofficial] */
  1713.       PC++;
  1714.       goto next;
  1715.  
  1716.     opcode_65: /* ADC ab */
  1717.       ZPAGE;
  1718.       data = memory[addr];
  1719.       goto adc;
  1720.  
  1721.     opcode_66: /* ROR ab */
  1722.       ZPAGE;
  1723.       data = memory[addr];
  1724.       if (C)
  1725.     {
  1726.       C = data & 1;
  1727.       Z = N = (data >> 1) | 0x80;
  1728.     }
  1729.       else
  1730.     {
  1731.       C = data & 1;
  1732.       Z = N = (data >> 1);
  1733.     }
  1734.       memory[addr] = Z;
  1735.       goto next;
  1736.  
  1737.     opcode_67: /* #RRA ab */
  1738.       ZPAGE;
  1739.       data = memory[addr];
  1740.       if (C)
  1741.     {
  1742.       C = data & 1;
  1743.       data = (data >> 1) | 0x80;
  1744.     }
  1745.       else
  1746.     {
  1747.       C = data & 1;
  1748.       data = (data >> 1);
  1749.     }
  1750.       memory[addr] = data;
  1751.       goto adc;
  1752.  
  1753.     opcode_68: /* PLA */
  1754.       Z = N = A = memory[0x0100 + MASK_FF(++S)];
  1755.       goto next;
  1756.  
  1757.     opcode_69: /* ADC #ab */
  1758.       data = memory[PC++];
  1759.       goto adc;
  1760.  
  1761.     opcode_6a: /* ROR */
  1762.       if (C)
  1763.     {
  1764.       C = A & 1;
  1765.       Z = N = A = (A >> 1) | 0x80;
  1766.     }
  1767.       else
  1768.     {
  1769.       C = A & 1;
  1770.       Z = N = A = (A >> 1);
  1771.     }
  1772.       goto next;      
  1773.  
  1774.     opcode_6c: /* JMP (abcd) */
  1775.       addr = (memory[PC+1] << 8) | memory[PC];
  1776.       PC = (memory[addr+1] << 8) | memory[addr];
  1777.       goto next;
  1778.  
  1779.     opcode_6d: /* ADC abcd */
  1780.       ABSOLUTE;
  1781.       data = GetByte(addr);
  1782.       goto adc;
  1783.  
  1784.     opcode_6e: /* ROR abcd */
  1785.       ABSOLUTE;
  1786.       data = GetByte(addr);
  1787.       if (C)
  1788.     {
  1789.       C = data & 1;
  1790.       Z = N = (data >> 1) | 0x80;
  1791.     }
  1792.       else
  1793.     {
  1794.       C = data & 1;
  1795.       Z = N = (data >> 1);
  1796.     }
  1797.       PutByte(addr, Z);
  1798.       goto next;
  1799.  
  1800.     opcode_6f: /* #RRA abcd */
  1801.       ABSOLUTE;
  1802.       data = GetByte(addr);
  1803.       if (C)
  1804.     {
  1805.       C = data & 1;
  1806.       data = (data >> 1) | 0x80;
  1807.     }
  1808.       else
  1809.     {
  1810.       C = data & 1;
  1811.       data = (data >> 1);
  1812.     }
  1813.       PutByte(addr,data);
  1814.       goto adc;
  1815.  
  1816.     opcode_70: /* BVS */
  1817.       if (V)
  1818.     {
  1819.       SBYTE sdata = memory[PC];
  1820.       PC += (SWORD)sdata;
  1821.     }
  1822.       PC++;
  1823.       goto next;
  1824.  
  1825.     opcode_71: /* ADC (ab),y */
  1826.       INDIRECT_Y;
  1827.       data = GetByte(addr);
  1828.       goto adc;
  1829.  
  1830.     opcode_73: /* #RRA (ab),y */
  1831.       INDIRECT_Y;
  1832.       data = GetByte(addr);
  1833.       if (C)
  1834.     {
  1835.       C = data & 1;
  1836.       data = (data >> 1) | 0x80;
  1837.     }
  1838.       else
  1839.     {
  1840.       C = data & 1;
  1841.       data = (data >> 1);
  1842.     }
  1843.       PutByte(addr,data);
  1844.       goto adc;
  1845.  
  1846.     opcode_74: /* NOP (2 bytes) [unofficial] */
  1847.       PC++;
  1848.       goto next;
  1849.  
  1850.     opcode_75: /* ADC ab,x */
  1851.       ZPAGE_X;
  1852.       data = memory[addr];
  1853.       goto adc;
  1854.  
  1855.     opcode_76: /* ROR ab,x */
  1856.       ZPAGE_X;
  1857.       data = memory[addr];
  1858.       if (C)
  1859.     {
  1860.       C = data & 1;
  1861.       Z = N = (data >> 1) | 0x80;
  1862.     }
  1863.       else
  1864.     {
  1865.       C = data & 1;
  1866.       Z = N = (data >> 1);
  1867.     }
  1868.       memory[addr] = Z;
  1869.       goto next;
  1870.  
  1871.     opcode_77: /* #RRA ab,x */
  1872.       ZPAGE_X;
  1873.       data = memory[addr];
  1874.       if (C)
  1875.     {
  1876.       C = data & 1;
  1877.       data = (data >> 1) | 0x80;
  1878.     }
  1879.       else
  1880.     {
  1881.       C = data & 1;
  1882.       data = (data >> 1);
  1883.     }
  1884.       memory[addr] = data;
  1885.       goto adc;
  1886.  
  1887.     opcode_78: /* SEI */
  1888.       SetI;
  1889.       goto next;
  1890.  
  1891.     opcode_79: /* ADC abcd,y */
  1892.       ABSOLUTE_Y;
  1893.       data = GetByte(addr);
  1894.       goto adc;
  1895.  
  1896.     opcode_7a: /* NOP (1 byte) [unofficial] */
  1897.       goto next;
  1898.  
  1899.     opcode_7b: /* #RRA abcd,y */
  1900.       ABSOLUTE_Y;
  1901.       data = GetByte(addr);
  1902.       if (C)
  1903.     {
  1904.       C = data & 1;
  1905.       data = (data >> 1) | 0x80;
  1906.     }
  1907.       else
  1908.     {
  1909.       C = data & 1;
  1910.       data = (data >> 1);
  1911.     }
  1912.       PutByte(addr,data);
  1913.       goto adc;
  1914.  
  1915.     opcode_7c: /* NOP (3 bytes) [unofficial] */
  1916.       ABSOLUTE_X;
  1917.       data = GetByte(addr);
  1918.       goto next;
  1919.  
  1920.     opcode_7d: /* ADC abcd,x */
  1921.       ABSOLUTE_X;
  1922.       data = GetByte(addr);
  1923.       goto adc;
  1924.  
  1925.     opcode_7e: /* ROR abcd,x */
  1926.       ABSOLUTE_X;
  1927.       data = GetByte(addr);
  1928.       if (C)
  1929.     {
  1930.       C = data & 1;
  1931.       Z = N = (data >> 1) | 0x80;
  1932.     }
  1933.       else
  1934.     {
  1935.       C = data & 1;
  1936.       Z = N = (data >> 1);
  1937.     }
  1938.       PutByte(addr, Z);
  1939.       goto next;
  1940.  
  1941.     opcode_7f: /* #RRA abcd,x */
  1942.       ABSOLUTE_X;
  1943.       data = GetByte(addr);
  1944.       if (C)
  1945.     {
  1946.       C = data & 1;
  1947.       data = (data >> 1) | 0x80;
  1948.     }
  1949.       else
  1950.     {
  1951.       C = data & 1;
  1952.       data = (data >> 1);
  1953.     }
  1954.       PutByte(addr,data);
  1955.       goto adc;
  1956.  
  1957.     opcode_80: /* NOP (2 bytes) [unofficial] */
  1958.       PC++;
  1959.       goto next;
  1960.  
  1961.     opcode_81: /* STA (ab,x) */
  1962.       INDIRECT_X;
  1963.       PutByte(addr, A);
  1964.       goto next;
  1965.  
  1966.     opcode_82: /* NOP (2 bytes) [unofficial] */
  1967.       PC++;
  1968.       goto next;
  1969.  
  1970.     opcode_83: /* #AXS (ab,x) */
  1971.       INDIRECT_X;
  1972.       data = A & X;
  1973.       PutByte(addr,data);
  1974.       goto next;
  1975.  
  1976.     opcode_84: /* STY ab */
  1977.       ZPAGE;
  1978.       memory[addr] = Y;
  1979.       goto next;
  1980.  
  1981.     opcode_85: /* STA ab */
  1982.       ZPAGE;
  1983.       memory[addr] = A;
  1984.       goto next;
  1985.  
  1986.     opcode_86: /* STX ab */
  1987.       ZPAGE;
  1988.       memory[addr] = X;
  1989.       goto next;
  1990.  
  1991.     opcode_87: /* #AXS ab */
  1992.       ZPAGE;
  1993.       memory[addr] = A & X;
  1994.       goto next;
  1995.  
  1996.     opcode_88: /* DEY */
  1997.       Z = N = --Y;
  1998.       goto next;
  1999.  
  2000.     opcode_89: /* NOP (2 bytes) [unofficial] */
  2001.       PC++;
  2002.       goto next;
  2003.  
  2004.     opcode_8a: /* TXA */
  2005.       Z = N = A = X;
  2006.       goto next;
  2007.  
  2008.     opcode_8c: /* STY abcd */
  2009.       ABSOLUTE;
  2010.       PutByte(addr, Y);
  2011.       goto next;
  2012.  
  2013.     opcode_8d: /* STA abcd */
  2014.       ABSOLUTE;
  2015.       PutByte(addr, A);
  2016.       goto next;
  2017.  
  2018.     opcode_8e: /* STX abcd */
  2019.       ABSOLUTE;
  2020.       PutByte(addr, X);
  2021.       goto next;
  2022.  
  2023.     opcode_8f: /* #AXS abcd */
  2024.       ABSOLUTE;
  2025.       data = A & X;
  2026.       PutByte(addr,data);
  2027.       goto next;
  2028.  
  2029.     opcode_90: /* BCC */
  2030.       if (!C)
  2031.     {
  2032.       SBYTE sdata = memory[PC];
  2033.       PC += (SWORD)sdata;
  2034.     }
  2035.       PC++;
  2036.       goto next;
  2037.  
  2038.     opcode_91: /* STA (ab),y */
  2039.       INDIRECT_Y;
  2040.       PutByte(addr, A);
  2041.       goto next;
  2042.  
  2043.     opcode_93: /* #AXA (ab),y */
  2044.       INDIRECT_Y;
  2045.       data = A & X & memory[PC-1];
  2046.       PutByte(addr,data);
  2047.       goto next;
  2048.  
  2049.     opcode_94: /* STY ab,x */
  2050.       ZPAGE_X;
  2051.       memory[addr] = Y;
  2052.       goto next;
  2053.  
  2054.     opcode_95: /* STA ab,x */
  2055.       ZPAGE_X;
  2056.       memory[addr] = A;
  2057.       goto next;
  2058.  
  2059.     opcode_96: /* STX ab,y */
  2060.       ZPAGE_Y;
  2061.       /* PutByte(addr, X); */
  2062.       memory[addr] = X;
  2063.       goto next;
  2064.       
  2065.     opcode_97: /* #AXS ab,y */
  2066.       ZPAGE_Y;
  2067.       data = A & X;
  2068.       memory[addr] = data;
  2069.       goto next;
  2070.  
  2071.     opcode_98: /* TYA */
  2072.       Z = N = A = Y;
  2073.       goto next;
  2074.  
  2075.     opcode_99: /* STA abcd,y */
  2076.       ABSOLUTE_Y;
  2077.       PutByte(addr, A);
  2078.       goto next;
  2079.  
  2080.     opcode_9a: /* TXS */
  2081.       S = X;
  2082.       goto next;
  2083.  
  2084.     opcode_9b: /* #TAS abcd,y */
  2085.       ABSOLUTE_Y;
  2086.       data = A & X;
  2087.       memory[0x0100 + MASK_FF(S--)] = data;
  2088.       data &= memory[PC-1]+1;
  2089.       PutByte(addr,data);
  2090.       goto next;
  2091.  
  2092.     opcode_9c: /* #SAY abcd,x */
  2093.       ABSOLUTE_X;
  2094.       data = Y & memory[PC-1];
  2095.       PutByte(addr,data);
  2096.       goto next;
  2097.  
  2098.     opcode_9d: /* STA abcd,x */
  2099.       ABSOLUTE_X;
  2100.       PutByte(addr, A);
  2101.       goto next;
  2102.  
  2103.     opcode_9e: /* #SAX abcd,y */
  2104.       ABSOLUTE_Y;
  2105.       data = X & memory[PC-1];
  2106.       PutByte(addr,data);
  2107.       goto next;
  2108.  
  2109.     opcode_9f: /* #AXA abcd,Y */
  2110.       ABSOLUTE_Y;
  2111.       data = X & A & memory[PC-1];
  2112.       PutByte(addr,data);
  2113.       goto next;
  2114.  
  2115.     opcode_a0: /* LDY #ab */
  2116.       LDY (memory[PC++]);
  2117.       goto next;
  2118.  
  2119.     opcode_a1: /* LDA (ab,x) */
  2120.       INDIRECT_X;
  2121.       LDA (GetByte(addr));
  2122.       goto next;
  2123.  
  2124.     opcode_a2: /* LDX #ab */
  2125.       LDX (memory[PC++]);
  2126.       goto next;
  2127.  
  2128.     opcode_a3: /* #LAX (ab,x) [unofficial] */
  2129.       INDIRECT_X;
  2130.       Z = N = X = A = GetByte (addr);
  2131.       goto next;
  2132.  
  2133.     opcode_a4: /* LDY ab */
  2134.       ZPAGE;
  2135.       LDY (memory[addr]);
  2136.       goto next;
  2137.  
  2138.     opcode_a5: /* LDA ab */
  2139.       ZPAGE;
  2140.       LDA (memory[addr]);
  2141.       goto next;
  2142.  
  2143.     opcode_a6: /* LDX ab */
  2144.       ZPAGE;
  2145.       LDX (memory[addr]);
  2146.       goto next;
  2147.  
  2148.     opcode_a7: /* #LAX ab [unofficial] */
  2149.       ZPAGE;
  2150.       Z = N = X = A = GetByte (addr);
  2151.       goto next;
  2152.  
  2153.     opcode_a8: /* TAY */
  2154.       Z = N = Y = A;
  2155.       goto next;
  2156.  
  2157.     opcode_a9: /* LDA #ab */
  2158.       LDA (memory[PC++]);
  2159.       goto next;
  2160.  
  2161.     opcode_aa: /* TAX */
  2162.       Z = N = X = A;
  2163.       goto next;
  2164.  
  2165.     opcode_ac: /* LDY abcd */
  2166.       ABSOLUTE;
  2167.       LDY (GetByte (addr));
  2168.       goto next;
  2169.  
  2170.     opcode_ad: /* LDA abcd */
  2171.       ABSOLUTE;
  2172.       LDA (GetByte(addr));
  2173.       goto next;
  2174.  
  2175.     opcode_ae: /* LDX abcd */
  2176.       ABSOLUTE;
  2177.       LDX (GetByte (addr));
  2178.       goto next;
  2179.  
  2180.     opcode_af: /* #LAX abcd [unofficial] */
  2181.       ABSOLUTE;
  2182.       Z = N = X = A = GetByte (addr);
  2183.       goto next;
  2184.  
  2185.     opcode_b0: /* BCS */
  2186.       if (C)
  2187.     {
  2188.       SBYTE sdata = memory[PC];
  2189.       PC += (SWORD)sdata;
  2190.     }
  2191.       PC++;
  2192.       goto next;
  2193.  
  2194.     opcode_b1: /* LDA (ab),y */
  2195.       INDIRECT_Y;
  2196.       LDA (GetByte(addr));
  2197.       goto next;
  2198.  
  2199.     opcode_b3: /* #LAX (ab),y [unofficial] */
  2200.       INDIRECT_Y;
  2201.       Z = N = X = A = GetByte (addr);
  2202.       goto next;
  2203.  
  2204.     opcode_b4: /* LDY ab,x */
  2205.       ZPAGE_X;
  2206.       LDY (memory[addr]);
  2207.       goto next;
  2208.  
  2209.     opcode_b5: /* LDA ab,x */
  2210.       ZPAGE_X;
  2211.       LDA (memory[addr]);
  2212.       goto next;
  2213.  
  2214.     opcode_b6: /* LDX ab,y */
  2215.       ZPAGE_Y;
  2216.       LDX (memory[addr]);
  2217.       goto next;
  2218.  
  2219.     opcode_b7: /* #LAX zpage,y [unofficial] */
  2220.       ZPAGE_Y;
  2221.       Z = N = X = A = memory[addr];
  2222.       goto next;
  2223.  
  2224.     opcode_b8: /* CLV */
  2225.       V = 0;
  2226.       goto next;
  2227.  
  2228.     opcode_b9: /* LDA abcd,y */
  2229.       ABSOLUTE_Y;
  2230.       LDA (GetByte(addr));
  2231.       goto next;
  2232.  
  2233.     opcode_ba: /* TSX */
  2234.       Z = N = X = S;
  2235.       goto next;
  2236.  
  2237.     opcode_bc: /* LDY abcd,x */
  2238.       ABSOLUTE_X;
  2239.       LDY (GetByte (addr));
  2240.       goto next;
  2241.  
  2242.     opcode_bd: /* LDA abcd,x */
  2243.       ABSOLUTE_X;
  2244.       LDA (GetByte(addr));
  2245.       goto next;
  2246.  
  2247.     opcode_be: /* LDX abcd,y */
  2248.       ABSOLUTE_Y;
  2249.       LDX (GetByte (addr));
  2250.       goto next;
  2251.  
  2252.     opcode_bf: /* #LAX abcd,y [unofficial] */
  2253.       ABSOLUTE_Y;
  2254.       Z = N = X = A = GetByte (addr);
  2255.       goto next;
  2256.  
  2257.     opcode_c0: /* CPY #ab */
  2258.       CPY (memory[PC++]);
  2259.       goto next;
  2260.  
  2261.     opcode_c1: /* CMP (ab,x) */
  2262.       INDIRECT_X;
  2263.       CMP (GetByte(addr));
  2264.       goto next;
  2265.  
  2266.     opcode_c2: /* NOP (2 bytes) [unofficial] */
  2267.       PC++;
  2268.       goto next;
  2269.  
  2270.     opcode_c3: /* #DCM (ab,x) */
  2271.       INDIRECT_X;
  2272.       data = GetByte(addr) - 1;
  2273.       PutByte(addr,data);
  2274.       CMP (data);
  2275.       goto next;
  2276.  
  2277.     opcode_c4: /* CPY ab */
  2278.       ZPAGE;
  2279.       CPY (memory[addr]);
  2280.       goto next;
  2281.  
  2282.     opcode_c5: /* CMP ab */
  2283.       ZPAGE;
  2284.       CMP (memory[addr]);
  2285.       goto next;
  2286.  
  2287.     opcode_c6: /* DEC ab */
  2288.       ZPAGE;
  2289.       Z = N = --memory[addr];
  2290.       goto next;
  2291.  
  2292.     opcode_c7: /* #DCM ab */
  2293.       ZPAGE;
  2294.       memory[addr]--;
  2295.       CMP (memory[addr]);
  2296.       goto next;
  2297.  
  2298.     opcode_c8: /* INY */
  2299.       Z = N = ++Y;
  2300.       goto next;
  2301.  
  2302.     opcode_c9: /* CMP #ab */
  2303.       CMP (memory[PC++]);
  2304.       goto next;
  2305.  
  2306.     opcode_ca: /* DEX */
  2307.       Z = N = --X;
  2308.       goto next;
  2309.  
  2310.     opcode_cc: /* CPY abcd */
  2311.       ABSOLUTE;
  2312.       CPY (GetByte(addr));
  2313.       goto next;
  2314.  
  2315.     opcode_cd: /* CMP abcd */
  2316.       ABSOLUTE;
  2317.       CMP (GetByte(addr));
  2318.       goto next;
  2319.  
  2320.     opcode_ce: /* DEC abcd */
  2321.       ABSOLUTE;
  2322.       Z = N = GetByte(addr) - 1;
  2323.       PutByte(addr, Z);
  2324.       goto next;
  2325.  
  2326.     opcode_cf: /* #DCM abcd */
  2327.       ABSOLUTE;
  2328.       data = GetByte(addr) - 1;
  2329.       PutByte(addr,data);
  2330.       CMP (data);
  2331.       goto next;
  2332.  
  2333.     opcode_d0: /* BNE */
  2334.       if (Z)
  2335.     {
  2336.       SBYTE sdata = memory[PC];
  2337.  
  2338.       PC += (SWORD)sdata;
  2339.     }
  2340.       PC++;
  2341.       goto next;
  2342.  
  2343.     opcode_d1: /* CMP (ab),y */
  2344.       INDIRECT_Y;
  2345.       CMP (GetByte(addr));
  2346.       goto next;
  2347.  
  2348.     opcode_d3: /* #DCM (ab),y */
  2349.       INDIRECT_Y;
  2350.       data = GetByte(addr) - 1;
  2351.       PutByte(addr,data);
  2352.       CMP (data);
  2353.       goto next;
  2354.  
  2355.     opcode_d4: /* NOP (2 bytes) [unofficial] */
  2356.       PC++;
  2357.       goto next;
  2358.  
  2359.     opcode_d5: /* CMP ab,x */
  2360.       ZPAGE_X;
  2361.       CMP (memory[addr]);
  2362.       Z = N = A - data;
  2363.       C = (A >= data);
  2364.       goto next;
  2365.  
  2366.     opcode_d6: /* DEC ab,x */
  2367.       ZPAGE_X;
  2368.       Z = N = --memory[addr];
  2369.       goto next;
  2370.  
  2371.     opcode_d7: /* #DCM ab,x */
  2372.       ZPAGE_X;
  2373.       data = memory[addr] - 1;
  2374.       memory[addr] = data;
  2375.       CMP (data);
  2376.       goto next;
  2377.  
  2378.     opcode_d8: /* CLD */
  2379.       ClrD;
  2380.       goto next;
  2381.  
  2382.     opcode_d9: /* CMP abcd,y */
  2383.       ABSOLUTE_Y;
  2384.       CMP (GetByte(addr));
  2385.       goto next;
  2386.  
  2387.     opcode_da: /* NOP (1 byte) [unofficial] */
  2388.       goto next;
  2389.  
  2390.     opcode_db: /* #DCM abcd,y */
  2391.       ABSOLUTE_Y;
  2392.       data = GetByte(addr) - 1;
  2393.       PutByte(addr,data);
  2394.       CMP (data);
  2395.       goto next;
  2396.  
  2397.     opcode_dc: /* NOP (3 bytes) [unofficial] */
  2398.       ABSOLUTE_X;
  2399.       data = GetByte(addr);
  2400.       goto next;
  2401.  
  2402.     opcode_dd: /* CMP abcd,x */
  2403.       ABSOLUTE_X;
  2404.       CMP (GetByte(addr));
  2405.       goto next;
  2406.  
  2407.     opcode_de: /* DEC abcd,x */
  2408.       ABSOLUTE_X;
  2409.       Z = N = GetByte(addr) - 1;
  2410.       PutByte(addr, Z);
  2411.       goto next;
  2412.  
  2413.     opcode_df: /* #DCM abcd,x */
  2414.       ABSOLUTE_X;
  2415.       data = GetByte(addr) - 1;
  2416.       PutByte(addr,data);
  2417.       CMP (data);
  2418.       goto next;
  2419.  
  2420.     opcode_e0: /* CPX #ab */
  2421.       CPX (memory[PC++]);
  2422.       goto next;
  2423.  
  2424.     opcode_e1: /* SBC (ab,x) */
  2425.       INDIRECT_X;
  2426.       data = GetByte(addr);
  2427.       goto sbc;
  2428.  
  2429.     opcode_e2: /* NOP (2 bytes) [unofficial] */
  2430.       PC++;
  2431.       goto next;
  2432.  
  2433.     opcode_e3: /* #INS (ab,x) */
  2434.       INDIRECT_X;
  2435.       data = GetByte(addr) + 1;
  2436.       PutByte(addr,data);
  2437.       goto sbc;
  2438.       
  2439.     opcode_e4: /* CPX ab */
  2440.       ZPAGE;
  2441.       CPX (memory[addr]);
  2442.       goto next;
  2443.  
  2444.     opcode_e5: /* SBC ab */
  2445.       ZPAGE;
  2446.       data = memory[addr];
  2447.       goto sbc;
  2448.  
  2449.     opcode_e6: /* INC ab */
  2450.       ZPAGE;
  2451.       Z = N = ++memory[addr];
  2452.       goto next;
  2453.  
  2454.     opcode_e7: /* #INS ab */
  2455.       ZPAGE;
  2456.       data = memory[addr] + 1;
  2457.       memory[addr] = data;
  2458.       goto sbc;
  2459.  
  2460.     opcode_e8: /* INX */
  2461.       Z = N = ++X;
  2462.       goto next;
  2463.  
  2464.     opcode_e9: /* SBC #ab */
  2465.       data = memory[PC++];
  2466.       goto sbc;
  2467.  
  2468.     opcode_ea: /* NOP */
  2469.       goto next;
  2470.  
  2471.     opcode_eb: /* #SBC # */
  2472.       data = memory[PC++];
  2473.       goto sbc;
  2474.      
  2475.     opcode_ec: /* CPX abcd */
  2476.       ABSOLUTE;
  2477.       CPX (GetByte (addr));
  2478.       goto next;
  2479.  
  2480.     opcode_ed: /* SBC abcd */
  2481.       ABSOLUTE;
  2482.       data = GetByte(addr);
  2483.       goto sbc;
  2484.  
  2485.     opcode_ee: /* INC abcd */
  2486.       ABSOLUTE;
  2487.       Z = N = GetByte(addr) + 1;
  2488.       PutByte(addr, Z);
  2489.       goto next;
  2490.  
  2491.     opcode_ef: /* #INS abcd */
  2492.       ABSOLUTE;
  2493.       data = GetByte(addr) + 1;
  2494.       PutByte(addr,data);
  2495.       goto sbc;
  2496.  
  2497.     opcode_f0: /* BEQ */
  2498.       if (!Z)
  2499.     {
  2500.       SBYTE sdata = memory[PC];
  2501.       PC += (SWORD)sdata;
  2502.     }
  2503.       PC++;
  2504.       goto next;
  2505.  
  2506.     opcode_f1: /* SBC (ab),y */
  2507.       INDIRECT_Y;
  2508.       data = GetByte(addr);
  2509.       goto sbc;
  2510.  
  2511.     opcode_f3: /* #INS (ab),y */
  2512.       INDIRECT_Y;
  2513.       data = GetByte(addr) + 1;
  2514.       PutByte(addr,data);
  2515.       goto sbc;
  2516.  
  2517.     opcode_f4: /* NOP (2 bytes) [unofficial] */
  2518.       PC++;
  2519.       goto next;
  2520.  
  2521.     opcode_f5: /* SBC ab,x */
  2522.       ZPAGE_X;
  2523.       data = memory[addr];
  2524.       goto sbc;
  2525.  
  2526.     opcode_f6: /* INC ab,x */
  2527.       ZPAGE_X;
  2528.       Z = N = ++memory[addr];
  2529.       goto next;
  2530.  
  2531.     opcode_f7: /* #INS ab,x */
  2532.       ZPAGE_X;
  2533.       data = memory[addr] + 1;
  2534.       memory[addr] = data;
  2535.       goto sbc;
  2536.  
  2537.     opcode_f8: /* SED */
  2538.       SetD;
  2539.       goto next;
  2540.  
  2541.     opcode_f9: /* SBC abcd,y */
  2542.       ABSOLUTE_Y;
  2543.       data = GetByte(addr);
  2544.       goto sbc;
  2545.  
  2546.     opcode_fa: /* NOP (1 byte) [unofficial] */
  2547.       goto next;
  2548.  
  2549.     opcode_fb: /* #INS abcd,Y */
  2550.       ABSOLUTE_Y;
  2551.       data = GetByte(addr) + 1;
  2552.       PutByte(addr,data);
  2553.       goto sbc;
  2554.  
  2555.     opcode_fc: /* NOP (3 bytes) [unofficial] */
  2556.       ABSOLUTE_X;
  2557.       data = GetByte(addr);
  2558.       goto next;
  2559.  
  2560.     opcode_fd: /* SBC abcd,x */
  2561.       ABSOLUTE_X;
  2562.       data = GetByte(addr);
  2563.       goto sbc;
  2564.  
  2565.     opcode_fe: /* INC abcd,x */
  2566.       ABSOLUTE_X;
  2567.       Z = N = GetByte(addr) + 1;
  2568.       PutByte(addr, Z);
  2569.       goto next;
  2570.  
  2571.     opcode_ff: /* #INS abcd,x */
  2572.       ABSOLUTE_X;
  2573.       data = GetByte(addr) + 1;
  2574.       PutByte(addr,data);
  2575.       goto sbc;
  2576.  
  2577.     opcode_d2: /* ESCRTS #ab (JAM) */
  2578.       data = memory[PC++];
  2579.       UPDATE_GLOBAL_REGS;
  2580.       CPU_GetStatus();
  2581.       Escape (data);
  2582.       CPU_PutStatus();
  2583.       UPDATE_LOCAL_REGS;
  2584.       data = memory[0x0100 + MASK_FF(++S)];
  2585.       PC = ((memory[0x0100 + MASK_FF(++S)] << 8) | data) + 1;
  2586.       goto next;
  2587.  
  2588.     opcode_f2: /* ESC #ab (JAM) */
  2589.       data = memory[PC++];
  2590.       UPDATE_GLOBAL_REGS;
  2591.       CPU_GetStatus();
  2592.       Escape (data);
  2593.       CPU_PutStatus();
  2594.       UPDATE_LOCAL_REGS;
  2595.       goto next;
  2596.  
  2597.     opcode_cb:
  2598.     opcode_bb:
  2599.     opcode_ab:
  2600.     opcode_8b:
  2601.     opcode_6b:
  2602.       UPDATE_GLOBAL_REGS;
  2603.       CPU_GetStatus();
  2604.       printf ("*** Unreliable opcode %02x at address %04x\n",
  2605.           memory[PC-1], PC-1);
  2606.       Atari800_Exit(TRUE, 0);
  2607.       CPU_PutStatus();
  2608.       UPDATE_LOCAL_REGS;
  2609.       ncycles = 0;
  2610.       break;
  2611.       
  2612.     opcode_02:
  2613.     opcode_12:
  2614.     opcode_22:
  2615.     opcode_32:
  2616.     opcode_42:
  2617.     opcode_52:
  2618.     opcode_62:
  2619.     opcode_72:
  2620.     opcode_92:
  2621.     opcode_b2:
  2622.       UPDATE_GLOBAL_REGS;     
  2623.       CPU_GetStatus();
  2624.       printf ("*** Crash opcode %02x at address %04x\n",
  2625.           memory[PC-1], PC-1);
  2626.       Atari800_Exit(TRUE, 0);
  2627.       CPU_PutStatus();
  2628.       UPDATE_LOCAL_REGS;
  2629.       ncycles = 0;
  2630.       break;
  2631.  
  2632.     adc:
  2633.       if (!(regP & D_FLAG))
  2634.     {
  2635.       UWORD    temp;
  2636.           UWORD t_data;
  2637.  
  2638.           t_data = (UWORD)data + (UWORD)C;
  2639.       Z = N = temp = (UWORD)A + t_data;
  2640.  
  2641.       V = (~(A ^ t_data)) & (Z ^ A) & 0x80;
  2642.       C = temp >> 8;
  2643.       A = Z;
  2644.     }
  2645.       else
  2646.     {
  2647.       int    bcd1, bcd2;
  2648.  
  2649.       bcd1 = BCDtoDEC[A];
  2650.       bcd2 = BCDtoDEC[data];
  2651.  
  2652.       bcd1 += bcd2 + C;
  2653.  
  2654.       Z = N = DECtoBCD[bcd1];
  2655.  
  2656.       V = (Z ^ A) & 0x80;
  2657.       C = (bcd1 > 99);
  2658.       A = Z;
  2659.     }
  2660.       goto next;
  2661.  
  2662.     sbc:
  2663.       if (!(regP & D_FLAG))
  2664.     {
  2665.       UWORD    temp;
  2666.           UWORD t_data;
  2667.  
  2668.           t_data = (UWORD)data + (UWORD)!C;
  2669.       temp = (UWORD)A - t_data;
  2670.  
  2671.       Z = N = temp & 0xff;
  2672.  
  2673. /*
  2674.  * This was the old code that I have been using upto version 0.5.2
  2675.  *  C = (A < ((UWORD)data + (UWORD)!C)) ? 0 : 1;
  2676.  */
  2677.       V = (~(A ^ t_data)) & (Z ^ A) & 0x80;
  2678.       C = (temp > 255) ? 0 : 1;
  2679.       A = Z;
  2680.     }
  2681.       else
  2682.     {
  2683.       int    bcd1, bcd2;
  2684.  
  2685.       bcd1 = BCDtoDEC[A];
  2686.       bcd2 = BCDtoDEC[data];
  2687.  
  2688.       bcd1 = bcd1 - bcd2 - !C;
  2689.  
  2690.       if (bcd1 < 0) bcd1 = 100 - (-bcd1);
  2691.       Z = N = DECtoBCD[bcd1];
  2692.  
  2693.       C = (A < (data + !C)) ? 0 : 1;
  2694.       V = (Z ^ A) & 0x80;
  2695.       A = Z;
  2696.     }
  2697.       goto next;
  2698.  
  2699.     next:
  2700.       continue;
  2701.     }
  2702.  
  2703.   UPDATE_GLOBAL_REGS;
  2704.   
  2705.   return ncycles;
  2706.  
  2707. /* This label is jumped at if a STA WSYNC is located */
  2708.  halt_cpu:
  2709.   UPDATE_GLOBAL_REGS;
  2710.   return wsync_bonus;
  2711.  
  2712. }
  2713.